package insertion_sort;

public class Sort {

    /*
    * 直接插入排序
    * 时间复杂度：最坏：O（n^2） 最好：O（n）
    * 空间复杂度：O（1）
    * 稳定
    * */
    public static void directInsertionSort(int[] array){
        for(int i=1;i<array.length;i++){
            int temp = array[i];
            int j=i-1;
            for(;j>=0;j--){
                //这里加不加等号和稳定性有关系
                //本身稳定的排序 可以变为不稳定
                //本身不稳定的排序 不可能变为稳定
                if(array[j]>temp){
                    array[j+1]=array[j];
                }else{
                    //array[j+1]=temp;
                    break;
                }
            }
            array[j+1]=temp;
        }
    }
    //指定区间插入排序 快速排序优化时使用
    public static void directInsertionSort(int[] array,int left,int right){
        for(int i=left+1;i<right;i++){
            int temp = array[i];
            int j=i-1;
            for(;j>=0;j--){
                if(array[j]>temp){
                    array[j+1]=array[j];
                }else{
                    //array[j+1]=temp;
                    break;
                }
            }
            array[j+1]=temp;
        }
    }

    /*
     * 希尔排序
     * 时间复杂度：
     * 空间复杂度：O（1）
     * 不稳定
     * */
    public static void shellSort(int[] array){
        int gap = array.length;
        while(gap>1) {
            gap /= 2;
            shell(array,gap);
        }
    }
    public static void shell(int[] array,int gap){
        for(int i=gap;i<array.length;i++){
            int temp = array[i];
            int j=i-gap;
            for(;j>=0;j-=gap){
                //这里加不加等号和稳定性有关系
                //本身稳定的排序 可以变为不稳定
                //本身不稳定的排序 不可能变为稳定
                if(array[j]>temp){
                    array[j+gap]=array[j];
                }else{
                    //array[j+1]=temp;
                    break;
                }
            }
            array[j+gap]=temp;
        }
    }
}
